home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / diskspace.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  26.0 KB  |  983 lines
  1. /*
  2.  *    @(#) diskspace.c 12.1 95/05/09 
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S000, 30-Sep-92, rickra
  22.  *     Initial check in.    
  23.  */
  24. /*+-------------------------------------------------------------------------
  25.     diskspace.c - XSW disk space display handler
  26.  
  27.   Defined functions:
  28.     draw_disk_space_literals(x,y)
  29.     update_disk_space()
  30.  
  31. --------------------------------------------------------------------------*/
  32.  
  33.  
  34. #include <X11/Xlib.h>
  35. #include <X11/Xutil.h>
  36. #include <X11/Intrinsic.h>
  37. #include <X11/Shell.h>
  38. #include <Xm/Xm.h>
  39. #include <Xm/MainW.h>
  40. #include <Xm/DrawingA.h>
  41.  
  42. #include "include/unixincs.h"
  43. #include "include/buttons.h"
  44. #include "include/xsw.h"
  45.  
  46. extern struct NetworkXswStruct *current_server;
  47.  
  48. int             diskspace_tlx;
  49. int             diskspace_tly;
  50.  
  51.  
  52. /*-------------------------------------------------------------------------
  53.         disk_space_total_compare(ppp1,ppp2)
  54. --------------------------------------------------------------------------*/
  55. disk_space_total_compare (ppp1, ppp2)
  56.      register disk_space *ppp1;
  57.      register disk_space *ppp2;
  58. {
  59.  
  60.   if (current_server ->
  61.       disk_space_sort_order == 1)
  62.     return (ppp2 -> f_blocks - ppp1 -> f_blocks);
  63.   else
  64.     return (ppp1 -> f_blocks - ppp2 -> f_blocks);
  65.  
  66. }                /* end of disk_space_total_compare */
  67.  
  68. /*-------------------------------------------------------------------------
  69.         disk_space_free_compare(ppp1,ppp2)
  70. --------------------------------------------------------------------------*/
  71. disk_space_free_compare (ppp1, ppp2)
  72.      register disk_space *ppp1;
  73.      register disk_space *ppp2;
  74. {
  75.  
  76.   if (current_server ->
  77.       disk_space_sort_order == 1)
  78.     return (ppp2 -> f_bfree - ppp1 -> f_bfree);
  79.   else
  80.     return (ppp1 -> f_bfree - ppp2 -> f_bfree);
  81.  
  82. }                /* end of disk_space_free_compare */
  83.  
  84. /*-------------------------------------------------------------------------
  85.         disk_space_used_compare(ppp1,ppp2)
  86. --------------------------------------------------------------------------*/
  87. disk_space_used_compare (ppp1, ppp2)
  88.      register disk_space *ppp1;
  89.      register disk_space *ppp2;
  90. {
  91.  
  92.   if (current_server ->
  93.       disk_space_sort_order == 1)
  94.     return ((ppp2 -> f_blocks - ppp2 -> f_bfree) -
  95.         (ppp1 -> f_blocks - ppp1 -> f_bfree));
  96.   else
  97.     return ((ppp1 -> f_blocks - ppp1 -> f_bfree) -
  98.         (ppp2 -> f_blocks - ppp2 -> f_bfree));
  99.  
  100. }                /* end of disk_space_used_compare */
  101.  
  102. /*-------------------------------------------------------------------------
  103.         disk_space_percent_used_compare(ppp1,ppp2)
  104.  
  105. NOTE: The return value MUST be an integer.... Should revisit this...
  106. --------------------------------------------------------------------------*/
  107. disk_space_percent_used_compare (ppp1, ppp2)
  108.      register disk_space *ppp1;
  109.      register disk_space *ppp2;
  110. {
  111.  
  112.   if ((ppp2 -> f_blocks == 0) && (ppp1 -> f_blocks == 0))
  113.     return (0);
  114.   else if (ppp2 -> f_blocks == 0)
  115.     return (-1);
  116.   else if (ppp1 -> f_blocks == 0)
  117.     return (1);
  118.  
  119.   if (current_server ->
  120.       disk_space_sort_order == 1)
  121.     return ((((ppp2 -> f_blocks - ppp2 -> f_bfree) * 100) / ppp2 -> f_blocks) -
  122.      (((ppp1 -> f_blocks - ppp1 -> f_bfree) * 100) / ppp1 -> f_blocks));
  123.   else
  124.     return ((((ppp1 -> f_blocks - ppp1 -> f_bfree) * 100) / ppp1 -> f_blocks) -
  125.      (((ppp2 -> f_blocks - ppp2 -> f_bfree) * 100) / ppp2 -> f_blocks));
  126.  
  127. }                /* end of disk_space_percent_used_compare */
  128.  
  129. /*-------------------------------------------------------------------------
  130.         disk_space_percent_free_compare(ppp1,ppp2)
  131.  
  132. NOTE: The return value MUST be an integer.... Should revisit this...
  133. --------------------------------------------------------------------------*/
  134. disk_space_percent_free_compare (ppp1, ppp2)
  135.      register disk_space *ppp1;
  136.      register disk_space *ppp2;
  137. {
  138.  
  139.   if ((ppp2 -> f_blocks == 0) && (ppp1 -> f_blocks == 0))
  140.     return (0);
  141.   else if (ppp2 -> f_blocks == 0)
  142.     return (-1);
  143.   else if (ppp1 -> f_blocks == 0)
  144.     return (1);
  145.  
  146.   if (current_server ->
  147.       disk_space_sort_order == 1)
  148.     return (((ppp2 -> f_bfree * 100) / ppp2 -> f_blocks) -
  149.         ((ppp1 -> f_bfree * 100) / ppp1 -> f_blocks));
  150.   else
  151.     return (((ppp1 -> f_bfree * 100) / ppp1 -> f_blocks) -
  152.         ((ppp2 -> f_bfree * 100) / ppp2 -> f_blocks));
  153.  
  154. }                /* end of disk_space_percent_free_compare */
  155.  
  156.  
  157. /*-------------------------------------------------------------------------
  158.         disk_space_itotal_compare(ppp1,ppp2)
  159. --------------------------------------------------------------------------*/
  160. disk_space_itotal_compare (ppp1, ppp2)
  161.      register disk_space *ppp1;
  162.      register disk_space *ppp2;
  163. {
  164.  
  165.   if (current_server ->
  166.       disk_space_sort_order == 1)
  167.     return (ppp2 -> f_files - ppp1 -> f_files);
  168.   else
  169.     return (ppp1 -> f_files - ppp2 -> f_files);
  170.  
  171. }                /* end of disk_space_total_compare */
  172.  
  173. /*-------------------------------------------------------------------------
  174.         disk_space_iused_compare(ppp1,ppp2)
  175. --------------------------------------------------------------------------*/
  176. disk_space_iused_compare (ppp1, ppp2)
  177.      register disk_space *ppp1;
  178.      register disk_space *ppp2;
  179. {
  180.  
  181.   if (current_server ->
  182.       disk_space_sort_order == 1)
  183.     return (
  184.          (ppp2 -> f_files - ppp2 -> f_ffree) -
  185.          (ppp1 -> f_files - ppp1 -> f_ffree));
  186.   else
  187.     return (
  188.          (ppp1 -> f_files - ppp1 -> f_ffree) -
  189.          (ppp2 -> f_files - ppp2 -> f_ffree));
  190.  
  191. }                /* end of disk_space_iused_compare */
  192.  
  193. /*-------------------------------------------------------------------------
  194.         disk_space_ifree_compare(ppp1,ppp2)
  195. --------------------------------------------------------------------------*/
  196. disk_space_ifree_compare (ppp1, ppp2)
  197.      register disk_space *ppp1;
  198.      register disk_space *ppp2;
  199. {
  200.  
  201.  
  202.   if (current_server ->
  203.       disk_space_sort_order == 1)
  204.     return (ppp2 -> f_ffree - ppp1 -> f_ffree);
  205.   else
  206.     return (ppp1 -> f_ffree - ppp2 -> f_ffree);
  207.  
  208. }                /* end of disk_space_ifree_compare */
  209.  
  210. /*-------------------------------------------------------------------------
  211.         disk_space_percent_iused_compare(ppp1,ppp2)
  212.  
  213. NOTE: The return value MUST be an integer.... Should revisit this...
  214. --------------------------------------------------------------------------*/
  215. disk_space_percent_iused_compare (ppp1, ppp2)
  216.      register disk_space *ppp1;
  217.      register disk_space *ppp2;
  218. {
  219.  
  220.   if ((ppp2 -> f_files == 0) && (ppp1 -> f_files == 0))
  221.     return (0);
  222.   else if (ppp2 -> f_files == 0)
  223.     return (-1);
  224.   else if (ppp1 -> f_files == 0)
  225.     return (1);
  226.  
  227.  
  228.  
  229.   if (current_server ->
  230.       disk_space_sort_order == 1)
  231.     return ((((ppp2 -> f_files - ppp2 -> f_ffree) * 100) / ppp2 -> f_files) -
  232.         (((ppp1 -> f_files - ppp1 -> f_ffree) * 100) / ppp1 -> f_files));
  233.   else
  234.     return ((((ppp1 -> f_files - ppp1 -> f_ffree) * 100) / ppp1 -> f_files) -
  235.         (((ppp2 -> f_files - ppp2 -> f_ffree) * 100) / ppp2 -> f_files));
  236.  
  237. }                /* end of disk_space_percent_iused_compare */
  238.  
  239. /*-------------------------------------------------------------------------
  240.         disk_space_percent_ifree_compare(ppp1,ppp2)
  241.  
  242. NOTE: The return value MUST be an integer.... Should revisit this...
  243. --------------------------------------------------------------------------*/
  244. disk_space_percent_ifree_compare (ppp1, ppp2)
  245.      register disk_space *ppp1;
  246.      register disk_space *ppp2;
  247. {
  248.  
  249.   if ((ppp2 -> f_files == 0) && (ppp1 -> f_files == 0))
  250.     return (0);
  251.   else if (ppp2 -> f_files == 0)
  252.     return (-1);
  253.   else if (ppp1 -> f_files == 0)
  254.     return (1);
  255.  
  256.   if (current_server ->
  257.       disk_space_sort_order == 1)
  258.  
  259.     return (((ppp2 -> f_ffree * 100) / ppp2 -> f_files) -
  260.         ((ppp1 -> f_ffree * 100) / ppp1 -> f_files));
  261.   else
  262.     return (((ppp1 -> f_ffree * 100) / ppp1 -> f_files) -
  263.         ((ppp2 -> f_ffree * 100) / ppp2 -> f_ffree));
  264.  
  265. }                /* end of disk_space_percent_ifree_compare */
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273. /*-------------------------------------------------------------------------
  274.         disk_space_mount_compare(ppp1,ppp2)
  275. --------------------------------------------------------------------------*/
  276. disk_space_mount_compare (ppp1, ppp2)
  277.      register disk_space *ppp1;
  278.      register disk_space *ppp2;
  279. {
  280.  
  281.   if (current_server ->
  282.       disk_space_sort_order == 1)
  283.     return (strcmp (ppp2 -> dir, ppp1 -> dir));
  284.   else
  285.     return (strcmp (ppp1 -> dir, ppp2 -> dir));
  286.  
  287. }                /* end of disk_space_mount_compare */
  288.  
  289. sort_disk_space ()
  290. {
  291.   switch (current_server -> disk_space_screen_mode)
  292.     {
  293.  
  294.     case 1:
  295.  
  296.       switch (current_server -> disk_space_sort_mode[0])
  297.     {
  298.     case 0:
  299.       (void) qsort ((char *) current_server -> current_disk_space,
  300.             (unsigned) current_server -> current_disk_space_entries,
  301.             sizeof (disk_space),
  302.             disk_space_total_compare);
  303.       break;
  304.     case 1:
  305.       (void) qsort ((char *) current_server -> current_disk_space,
  306.             (unsigned) current_server -> current_disk_space_entries,
  307.             sizeof (disk_space),
  308.             disk_space_used_compare);
  309.       break;
  310.     case 2:
  311.       (void) qsort ((char *) current_server -> current_disk_space,
  312.             (unsigned) current_server -> current_disk_space_entries,
  313.             sizeof (disk_space),
  314.             disk_space_free_compare);
  315.       break;
  316.     case 3:
  317.       (void) qsort ((char *) current_server -> current_disk_space,
  318.             (unsigned) current_server -> current_disk_space_entries,
  319.             sizeof (disk_space),
  320.             disk_space_percent_used_compare);
  321.       break;
  322.     case 4:
  323.       (void) qsort ((char *) current_server -> current_disk_space,
  324.             (unsigned) current_server -> current_disk_space_entries,
  325.             sizeof (disk_space),
  326.             disk_space_percent_free_compare);
  327.       break;
  328.     case 5:
  329.       (void) qsort ((char *) current_server -> current_disk_space,
  330.             (unsigned) current_server -> current_disk_space_entries,
  331.             sizeof (disk_space),
  332.             disk_space_mount_compare);
  333.       break;
  334.     }
  335.  
  336.  
  337.       break;
  338.  
  339.     case 2:
  340.       switch (current_server -> disk_space_sort_mode[1])
  341.     {
  342.     case 0:
  343.       (void) qsort ((char *) current_server -> current_disk_space,
  344.             (unsigned) current_server -> current_disk_space_entries,
  345.             sizeof (disk_space),
  346.             disk_space_total_compare);
  347.       break;
  348.  
  349.     case 1:
  350.       (void) qsort ((char *) current_server -> current_disk_space,
  351.             (unsigned) current_server -> current_disk_space_entries,
  352.             sizeof (disk_space),
  353.             disk_space_used_compare);
  354.       break;
  355.     case 2:
  356.       (void) qsort ((char *) current_server -> current_disk_space,
  357.             (unsigned) current_server -> current_disk_space_entries,
  358.             sizeof (disk_space),
  359.             disk_space_free_compare);
  360.       break;
  361.     case 3:
  362.       (void) qsort ((char *) current_server -> current_disk_space,
  363.             (unsigned) current_server -> current_disk_space_entries,
  364.             sizeof (disk_space),
  365.             disk_space_percent_used_compare);
  366.       break;
  367.     case 4:
  368.       (void) qsort ((char *) current_server -> current_disk_space,
  369.             (unsigned) current_server -> current_disk_space_entries,
  370.             sizeof (disk_space),
  371.             disk_space_percent_free_compare);
  372.       break;
  373.     case 5:
  374.       (void) qsort ((char *) current_server -> current_disk_space,
  375.             (unsigned) current_server -> current_disk_space_entries,
  376.             sizeof (disk_space),
  377.             disk_space_mount_compare);
  378.       break;
  379.  
  380.     }
  381.  
  382.       break;
  383.  
  384.     case 3:
  385.       switch (current_server -> disk_space_sort_mode[2])
  386.     {
  387.     case 0:
  388.       (void) qsort ((char *) current_server -> current_disk_space,
  389.             (unsigned) current_server -> current_disk_space_entries,
  390.             sizeof (disk_space),
  391.             disk_space_itotal_compare);
  392.       break;
  393.     case 1:
  394.       (void) qsort ((char *) current_server -> current_disk_space,
  395.             (unsigned) current_server -> current_disk_space_entries,
  396.             sizeof (disk_space),
  397.             disk_space_iused_compare);
  398.       break;
  399.     case 2:
  400.       (void) qsort ((char *) current_server -> current_disk_space,
  401.             (unsigned) current_server -> current_disk_space_entries,
  402.             sizeof (disk_space),
  403.             disk_space_ifree_compare);
  404.       break;
  405.     case 3:
  406.       (void) qsort ((char *) current_server -> current_disk_space,
  407.             (unsigned) current_server -> current_disk_space_entries,
  408.             sizeof (disk_space),
  409.             disk_space_percent_iused_compare);
  410.       break;
  411.     case 4:
  412.       (void) qsort ((char *) current_server -> current_disk_space,
  413.             (unsigned) current_server -> current_disk_space_entries,
  414.             sizeof (disk_space),
  415.             disk_space_percent_ifree_compare);
  416.       break;
  417.     case 5:
  418.       (void) qsort ((char *) current_server -> current_disk_space,
  419.             (unsigned) current_server -> current_disk_space_entries,
  420.             sizeof (disk_space),
  421.             disk_space_mount_compare);
  422.       break;
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.     }
  430.       break;
  431.  
  432.     }
  433.  
  434.  
  435. }
  436.  
  437. unsigned long
  438. get_disk_space_pixel (current, bak)
  439.  
  440.      float           current, bak;
  441.  
  442. {
  443.  
  444.   if (current > bak)
  445.     return (colorDiskspaceGaining.pixel);
  446.   else if (current < bak)
  447.     return (colorDiskspaceLosing.pixel);
  448.   else
  449.     return (colorDiskspaceStable.pixel);
  450.  
  451. }
  452.  
  453. /*+-------------------------------------------------------------------------
  454.     update_disk_space()
  455. --------------------------------------------------------------------------*/
  456. void
  457. update_disk_space (SP)
  458.      struct NetworkXswStruct *SP;
  459.  
  460. {
  461.   Window          window = SP -> 
  462.                   SEPERATE_WINDOWS_LIST[BUTTON_disk_space].window;
  463.   Display        *display = SP -> 
  464.                   SEPERATE_WINDOWS_LIST[BUTTON_disk_space].display;
  465.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].gc;
  466.   XWindowAttributes DrawAreaXYWH = SP -> 
  467.                SEPERATE_WINDOWS_LIST[BUTTON_disk_space].DrawAreaXYWH;
  468.   Pixmap          pixmap = SP -> 
  469.                SEPERATE_WINDOWS_LIST[BUTTON_disk_space].pixmap;
  470.  
  471.   register int    x, y;
  472.   int             fheight = FHEIGHT;
  473.  
  474.   unsigned long   pixel;
  475.   int             i;
  476.   int             w;
  477.   int             bak_index = -1;
  478.  
  479.   float           total_total = 0.0;
  480.   float           total_used = 0.0;
  481.  
  482.   float           total_free = 0.0;
  483.  
  484. /*
  485.  * Should keep track of previous total free across all views, otherwise
  486.  * switching views will cause the total to change color, perhaps to the
  487.  * WRONG color..... 
  488.  *
  489.  */
  490.  
  491.   static float    total_free_bak = 0.0;
  492.  
  493.   float           total_percent_used = 0.0;
  494.   float           total_percent_free = 0.0;
  495.  
  496.  
  497.  
  498.  
  499.   float           p_free_inodes;
  500.   float           p_used_inodes;
  501.   long            used_inodes;
  502.   float           p_free_blocks;
  503.   float           p_used_blocks;
  504.  
  505.   int             temp1;
  506.   int             temp2;
  507.  
  508.   int             drawn_number = 0;
  509.  
  510.  
  511.   y = diskspace_tly;
  512.   x = diskspace_tlx;
  513.  
  514.   XSetForeground (display, gc, background);
  515.   XFillRectangle (display, pixmap, gc, x, y, SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].width - x, FHEIGHT * SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].height - 1);
  516.  
  517.  
  518.   sort_disk_space ();
  519.  
  520.   for (w = 0; w < current_server -> current_disk_space_entries; w++)
  521.     {
  522.  
  523. /*
  524.  * If we have a nfs filesystem AND we should NOT show it, then skip this...
  525.  */
  526.  
  527.      if ( (current_server -> current_disk_space[w].nfs_filesystem == 1) &&
  528.       (current_server -> show_nfs == 0 ) )
  529.     continue;
  530.  
  531.       for (i = 0; i < current_server -> current_disk_space_entries_bak; i++)
  532.     {
  533.  
  534.       if (strcmp (current_server -> current_disk_space[w].dir,
  535.               current_server -> current_disk_space_bak[i].dir) == 0)
  536.         {
  537.           bak_index = i;
  538.           break;
  539.         }
  540.       else
  541.         bak_index = -1;
  542.  
  543.     }
  544.  
  545.  
  546.       x = diskspace_tlx;
  547.  
  548.       drawn_number++;
  549.  
  550. /*
  551.  * Clear the enitre line
  552.  */
  553.  
  554.       XSetForeground (display, gc, background);
  555.       XFillRectangle (display, pixmap, gc, x, y,
  556.           SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].draw_width - x,
  557.               FHEIGHT);
  558.  
  559.       if (current_server -> current_disk_space[w].problems == 1)
  560.     disp_info_text (window, display, gc, DrawAreaXYWH, x, y,
  561.             pixmap, colorNumericAlarm.pixel,
  562.             "?");
  563.       else
  564.     disp_info_text (window, display, gc, DrawAreaXYWH, x, y,
  565.             pixmap, colorLabel.pixel,
  566.             " ");
  567.       x += (FWIDTH);
  568.  
  569.  
  570.       switch (SP -> disk_space_screen_mode)
  571.     {
  572.  
  573.     case 1:
  574.  
  575.       {
  576.         float           total_mb;
  577.         float           total_mb_bak;
  578.  
  579.         float           free_mb;
  580.         float           free_mb_bak;
  581.  
  582.         float           used_mb;
  583.         float           used_mb_bak;
  584. /*
  585.  * calculate initial data
  586.  */
  587.  
  588.  
  589.         total_mb =
  590.           ((float) current_server ->
  591.            current_disk_space[w].f_blocks / 2) / 1024;
  592.  
  593.         total_total += total_mb;
  594.  
  595.  
  596.  
  597.         free_mb =
  598.           ((float) current_server ->
  599.            current_disk_space[w].f_bfree / 2) / 1024;
  600.  
  601.         total_free += free_mb;
  602.  
  603.         used_mb = total_mb - free_mb;
  604.  
  605.         total_used += used_mb;
  606.  
  607.  
  608.         if (bak_index != -1)
  609.           {
  610.  
  611.         total_mb_bak =
  612.           ((float) current_server ->
  613.            current_disk_space_bak[bak_index].f_blocks / 2)
  614.           / 1024;
  615.  
  616.         free_mb_bak =
  617.           ((float) current_server ->
  618.            current_disk_space_bak[bak_index].f_bfree / 2) / 1024;
  619.  
  620.         used_mb_bak = total_mb_bak - free_mb_bak;
  621.  
  622.           }
  623.  
  624.         pixel = get_disk_space_pixel (free_mb, free_mb_bak);
  625.  
  626.  
  627.  
  628.  
  629.  
  630.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  631.             "%8.2f", colorStaticNumeric.pixel, total_mb);
  632.         x += (FWIDTH * 10);
  633.  
  634.  
  635.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  636.             "%8.2f", pixel, used_mb);
  637.         x += (FWIDTH * 10);
  638.  
  639.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  640.             "%8.2f", pixel, free_mb);
  641.         x += (FWIDTH * 10);
  642.  
  643.  
  644.  
  645.         if (total_mb != 0)
  646.           {
  647.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  648.               "%8.2f%%", pixel, (float) (used_mb * 100) / total_mb);
  649.           }
  650.         else
  651.           disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  652.               "%8.2f%%", colorNumeric.pixel, 0);
  653.  
  654.         x += (FWIDTH * 10);
  655.  
  656.  
  657.         if (total_mb != 0)
  658.           {
  659.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  660.               "%8.2f%%", pixel, (float) (free_mb * 100) / total_mb);
  661.           }
  662.         else
  663.           disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  664.               "%8.2f%%", colorNumeric.pixel, 0);
  665.  
  666.         x += (FWIDTH * 10);
  667.  
  668.  
  669.         disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  670.                 colorLabel.pixel,
  671.               (char *) current_server -> current_disk_space[w].dir);
  672.  
  673.         x += (FWIDTH * 33);
  674.  
  675.         disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  676.                 colorLabel.pixel,
  677.               (char *) current_server -> current_disk_space[w].dev);
  678.  
  679.       }
  680.       break;
  681.  
  682.  
  683.     case 2:
  684.  
  685.       temp1 = current_server -> current_disk_space[w].f_bfree;
  686.       temp2 = current_server -> current_disk_space_bak[bak_index].f_bfree;
  687.  
  688.       if (temp1 > temp2)
  689.         pixel = colorDiskspaceGaining.pixel;
  690.       else if (temp1 < temp2)
  691.         pixel = colorDiskspaceLosing.pixel;
  692.       else
  693.         pixel = colorDiskspaceStable.pixel;
  694.  
  695.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  696.              "%8ld", colorStaticNumeric.pixel,
  697.              current_server -> current_disk_space[w].f_blocks);
  698.  
  699.       total_total += current_server -> current_disk_space[w].f_blocks;
  700.  
  701.       x += (FWIDTH * 10);
  702.  
  703.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  704.              "%8ld", pixel,
  705.              current_server -> current_disk_space[w].f_blocks -
  706.              current_server -> current_disk_space[w].f_bfree);
  707.       x += (FWIDTH * 10);
  708.  
  709.       total_used += (current_server -> current_disk_space[w].f_blocks -
  710.                      current_server -> current_disk_space[w].f_bfree);
  711.  
  712.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  713.              "%8ld", pixel,
  714.              current_server -> current_disk_space[w].f_bfree);
  715.       x += (FWIDTH * 10);
  716.  
  717.       total_free += current_server -> current_disk_space[w].f_bfree;
  718.  
  719.       if (current_server -> current_disk_space[w].f_blocks != 0)
  720.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  721.             "%8.2f%%", pixel,
  722.         (float) ((current_server -> current_disk_space[w].f_blocks -
  723.            current_server -> current_disk_space[w].f_bfree) * 100) /
  724.             current_server -> current_disk_space[w].f_blocks);
  725.       else
  726.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  727.             "%8.2f%%", colorNumeric.pixel, 0);
  728.  
  729.       x += (FWIDTH * 10);
  730.  
  731.       if (current_server -> current_disk_space[w].f_blocks != 0)
  732.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  733.             "%8.2f%%", pixel,
  734.         (float) (current_server -> current_disk_space[w].f_bfree * 100) /
  735.             current_server -> current_disk_space[w].f_blocks);
  736.       else
  737.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  738.             "%8.2f%%", colorNumeric.pixel, 0);
  739.  
  740.       x += (FWIDTH * 10);
  741.  
  742.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  743.               colorLabel.pixel,
  744.               (char *) current_server -> current_disk_space[w].dir);
  745.  
  746.       x += (FWIDTH * 33);
  747.  
  748.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  749.               colorLabel.pixel,
  750.               (char *) current_server -> current_disk_space[w].dev);
  751.  
  752.  
  753.       break;
  754.  
  755.     case 3:
  756.  
  757.       temp1 = current_server -> current_disk_space[w].f_ffree;
  758.       temp2 = current_server -> current_disk_space_bak[bak_index].f_ffree;
  759.  
  760.       if (temp1 > temp2)
  761.         pixel = colorDiskspaceGaining.pixel;
  762.       else if (temp1 < temp2)
  763.         pixel = colorDiskspaceLosing.pixel;
  764.       else
  765.         pixel = colorDiskspaceStable.pixel;
  766.  
  767.  
  768.       used_inodes = current_server -> current_disk_space[w].f_files -
  769.         current_server -> current_disk_space[w].f_ffree;
  770.  
  771.       if (current_server -> current_disk_space[w].f_files != 0)
  772.         p_free_inodes =
  773.           ((float) current_server ->
  774.            current_disk_space[w].f_ffree * 100) /
  775.           (float) current_server -> current_disk_space[w].f_files;
  776.  
  777.       if (current_server -> current_disk_space[w].f_files != 0)
  778.         p_used_inodes =
  779.           ((float) used_inodes * 100) /
  780.           (float) current_server -> current_disk_space[w].f_files;
  781.  
  782.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  783.              "%8ld", colorStaticNumeric.pixel,
  784.              current_server -> current_disk_space[w].f_files);
  785.  
  786.       x += (FWIDTH * 10);
  787.  
  788.       total_total += current_server -> current_disk_space[w].f_files;
  789.  
  790.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  791.              "%8ld", pixel, used_inodes);
  792.       x += (FWIDTH * 10);
  793.  
  794.       total_used += used_inodes;
  795.  
  796.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  797.              "%8ld", pixel,
  798.              current_server -> current_disk_space[w].f_ffree);
  799.       x += (FWIDTH * 10);
  800.  
  801.       total_free += current_server -> current_disk_space[w].f_ffree;
  802.  
  803.  
  804.       if (current_server -> current_disk_space[w].f_files != 0)
  805.         {
  806.           disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  807.               "%8.2f%%", pixel, p_used_inodes);
  808.         }
  809.       else
  810.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  811.             "%8.2f%%", colorNumeric.pixel, 0);
  812.  
  813.       x += (FWIDTH * 10);
  814.  
  815.       if (current_server -> current_disk_space[w].f_files != 0)
  816.         {
  817.           disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  818.               "%8.2f%%", pixel, p_free_inodes);
  819.         }
  820.       else
  821.         disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  822.             "%8.2f%%", colorNumeric.pixel, 0);
  823.  
  824.       x += (FWIDTH * 10);
  825.  
  826.  
  827.  
  828.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  829.               colorLabel.pixel,
  830.               (char *) current_server -> current_disk_space[w].dir);
  831.  
  832.       x += (FWIDTH * 33);
  833.  
  834.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  835.               colorLabel.pixel,
  836.               (char *) current_server -> current_disk_space[w].dev);
  837.  
  838.  
  839.       break;
  840.  
  841.  
  842.  
  843.     }
  844.  
  845. /*
  846.  * Jump to next line......
  847.  */
  848.  
  849.       y += +fheight;
  850.  
  851.     }
  852.  
  853.  
  854.  
  855.   x = diskspace_tlx;
  856.  
  857.  
  858. /*
  859.  * Clear everything below now....
  860.  */
  861.  
  862.   XSetForeground (display, gc, background);
  863.   XFillRectangle (display, pixmap, gc,
  864.           0, drawn_number * fheight,
  865.           SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].draw_width,
  866.         SP -> SEPERATE_WINDOWS_LIST[BUTTON_disk_space].draw_height);
  867.  
  868.  
  869.  
  870.  
  871.   if (current_server -> show_disk_totals == 1)
  872.     {
  873.  
  874.       pixel = get_disk_space_pixel (total_free, total_free_bak);
  875.  
  876.       XSetForeground (display, gc, colorDiskspaceStable.pixel);
  877.  
  878.       XDrawLine (display, pixmap, gc,
  879.              x, y,FWIDTH * 57,
  880. /*
  881.              DisplayWidth (display, screen), 
  882. */
  883.           y);
  884.  
  885.       XDrawLine (display, pixmap, gc,
  886.              x, y + (fheight /2),FWIDTH * 57,
  887. /*
  888.              DisplayWidth (display, screen),
  889. */
  890.          y + (fheight /2));
  891.  
  892. /*
  893.  
  894.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y,
  895.               pixmap, colorNumeric.pixel,
  896.        " ======== ========= ========= ========== ========= ==========");
  897. */
  898.  
  899.       y += +fheight;
  900.  
  901.       x += (FWIDTH);
  902.       switch (SP -> disk_space_screen_mode)
  903.     {
  904.  
  905.     case 1:
  906.  
  907.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  908.               "%8.2f", colorStaticNumeric.pixel, total_total);
  909.       x += (FWIDTH * 10);
  910.  
  911.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  912.               "%8.2f", pixel, total_used);
  913.       x += (FWIDTH * 10);
  914.  
  915.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  916.               "%8.2f", pixel, total_free);
  917.       x += (FWIDTH * 10);
  918.  
  919.       total_percent_used =
  920.         (float) (total_used * 100) / total_total;
  921.  
  922.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  923.               "%8.2f%%", pixel, (float) total_percent_used);
  924.       x += (FWIDTH * 10);
  925.  
  926.       total_percent_free =
  927.         (float) (total_free * 100) / total_total;
  928.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  929.               "%8.2f%%", pixel, (float) total_percent_free);
  930.       x += (FWIDTH * 10);
  931.  
  932.       break;
  933.  
  934.     case 2:
  935.     case 3:
  936.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  937.              "%8ld", colorStaticNumeric.pixel,
  938.              (int) total_total);
  939.       x += (FWIDTH * 10);
  940.  
  941.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  942.              "%8ld", pixel,
  943.              (int) total_used);
  944.       x += (FWIDTH * 10);
  945.  
  946.       disp_long (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  947.              "%8ld", pixel,
  948.              (int) total_free);
  949.       x += (FWIDTH * 10);
  950.  
  951.       total_percent_used =
  952.         (float) (total_used * 100) / total_total;
  953.  
  954.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  955.               "%8.2f%%", pixel, (float) total_percent_used);
  956.       x += (FWIDTH * 10);
  957.  
  958.       total_percent_free =
  959.         (float) (total_free * 100) / total_total;
  960.       disp_float (window, display, gc, DrawAreaXYWH, pixmap, x, y,
  961.               "%8.2f%%", pixel, (float) total_percent_free);
  962.       x += (FWIDTH * 10);
  963.  
  964.       break;
  965.  
  966.     }
  967.  
  968.       disp_info_text (window, display, gc, DrawAreaXYWH, x, y, pixmap,
  969.               colorLabel.pixel,
  970.               (char *) "TOTAL");
  971.  
  972.       x += (FWIDTH * 33);
  973.  
  974.  
  975.  
  976.  
  977.     }
  978.  
  979.   total_free_bak = total_free;
  980. }                /* end of update_disk_space */
  981.  
  982. /* end of diskspace.c */
  983.